// #include "blockqueue.hpp"
// #include "Thread_mutex.hpp"
// #include "sem.hpp"

// using namespace std;

// //生产者
// void funcofmain(TDataBlock& bd)
// {
//     // Task in = DownLoad;
//     while(true)
//     {
//         bd.Push(DownLoad);   
//         cout << "--funcofmain" << ">>生产in: " << endl;               
//         sleep(1);   
//     }
// }

// //消费者
// void funcofless(TDataBlock& bd)
// {
//     Task out;
//     while(true)
//     {
//         bd.Pop(out);  
//         out();
//         cout << "--funcofless" <<  ">>消费out: " << endl;    
//     }
// }

// void CommFunc(vector<TYPE>& vtb, int pthreadnum, function<void(TDataBlock&)> func, string what, RingQueue<DataType>& bq)
// {
//     for(int i=0; i<pthreadnum; i++)
//     {     
//         string thread_name = what + "-thread-" + to_string(i+1);    
//         vtb.emplace_back(func, bq);                
//     }
// }

// void MainThread(vector<TYPE>& vtb, int pthreadnum, RingQueue<DataType>& bq)
// {
//     CommFunc(vtb, pthreadnum, funcofmain, "main", bq);
// }

// void LessThread(vector<TYPE>& vtb, int pthreadnum, RingQueue<DataType>& bq)
// {
//     CommFunc(vtb, pthreadnum, funcofless, "less", bq);
// }

// void WaitThread(vector<TYPE>& vtb)
// {
//     for(auto &e: vtb) e.Join();
// }

// void StatrAll(vector<TYPE>& vtb)
// {
//     for(auto &e: vtb)
//     {
//         e.Start();
//     }
// }
// int main()
// {
//     int a = 10;

//     vector<TYPE> vtb1, vtb2;  
//     BlockQueue<DataType>* bq = new BlockQueue<DataType>(a);

//     MainThread(vtb1, 1, *bq);
//     LessThread(vtb2, 1, *bq);

//     WaitThread(vtb1);
//     WaitThread(vtb2);
//     return 0;
// }

// int main()
// {
//     int a = 10;

//     vector<TYPE> vtb;
//     RingQueue<DataType>* bq = new RingQueue<DataType>(a);

//     MainThread(vtb, 1, *bq);
//     LessThread(vtb, 3, *bq);

//     StatrAll(vtb);
//     WaitThread(vtb);
    

//     return 0;
// }



//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------


// void funcofmain(TDataBlock& bd)
// {
//     int cnt = 0;
//     while(true)
//     {
//         bd.Push(cnt);
//         cout  << "--funcofmain" << ">>生产cnt: " << cnt << endl;
//         sleep(1);

//         cnt++;
//     }
// }

// void funcofless(TDataBlock& bd)
// {
//     int cnt = 0;
//     while(true)
//     {
//         bd.Pop(cnt);
//         cout << "--funcofless" <<  ">>消费cnt: " << cnt << endl;
//         sleep(1);
//     }
// }

// void CommFunc(vector<TYPE>& vtb, int pthreadnum, function<void(TDataBlock&)> func, string what, BlockQueue<DataType>& bq)
// {
//     for(int i=0; i<pthreadnum; i++)
//     {     
//         string thread_name = what + "-thread-" + to_string(i+1);
        
//         vtb.emplace_back(func, bq, thread_name);
//         vtb.back().Start();                  
//     }
// }

// void MainThread(vector<TYPE>& vtb, int pthreadnum, BlockQueue<DataType>& bq)
// {
//     CommFunc(vtb, pthreadnum, funcofmain, "main", bq);
// }

// void LessThread(vector<TYPE>& vtb, int pthreadnum, BlockQueue<DataType>& bq)
// {
//     CommFunc(vtb, pthreadnum, funcofless, "less", bq);
// }

// void WaitThread(vector<TYPE>& vtb)
// {
//     for(auto &e: vtb) e.Join();
// }

// int main()
// {
//     int a = 10;
//     BlockQueue<int> *bq = new BlockQueue<int>(a);
//     vector<TYPE> vtb;

//     MainThread(vtb,1,*bq);
//     LessThread(vtb,1,*bq);
//     WaitThread(vtb);

//     return 0;
// }

//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------

// void func(ThreadData<int>& a)
// {
//     int cnt = 10;
//     while(cnt--)
//     {
//         cout << "Yes" << endl;
//         sleep(1);
//     } 
// }

// int main()
// {

//     vector<Thread<ThreadData<int>>> vt;
    
//     int a = 10;
//     string name = "jhfd";
//     ThreadData<int>* td = new ThreadData<int>(a, name);
//     ThreadData<int>* td2 = new ThreadData<int>(a, name);

//     vt.emplace_back(func, *td);
//     vt.back().CreateRun();
//     vt.emplace_back(func, *td2);
//     vt.back().CreateRun();   

//     vt[0].Join();
//     vt[1].Join();
//     return 0;
// }


//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------
//---------------------------------------------------------------------------------------
#include "ThreadPool.hpp"
#include <memory>

using namespace std;

int main()
{
    unique_ptr<ThreadPool<int>> threadpool = make_unique<ThreadPool<int>>(6);
    
    threadpool->ThreadInit();
    threadpool->Start();
    threadpool->Stop();
    threadpool->Wait();

    return 0;
}